package com.ruoyi.common.utils;

import java.io.Serializable;
import java.util.Iterator;
import java.util.StringTokenizer;

public class StringHelper implements Serializable {

    public static final String EMPTY_STRING = "";
    public static final char DOT = '.';
    public static final char UNDERSCORE = '_';
    public static final String COMMA_SPACE = ", ";
    public static final String COMMA = ",";
    public static final String OPEN_PAREN = "(";
    public static final String CLOSE_PAREN = ")";
    public static final char SINGLE_QUOTE = '\'';

    public static String join(String seperator, String[] strings) {
        int length = strings.length;
        if (length == 0) {
            return "";
        }

        StringBuffer buf = (new StringBuffer(length * strings[0].length())).append(strings[0]);
        for (int i = 1; i < length; i++) {
            buf.append(seperator).append(strings[i]);
        }
        return buf.toString();
    }

    public static String join(String seperator, Iterator objects) {
        StringBuffer buf = new StringBuffer();
        if (objects.hasNext()) {
            buf.append(objects.next());
        }
        while (objects.hasNext()) {
            buf.append(seperator).append(objects.next());
        }
        return buf.toString();
    }

    public static String[] add(String[] x, String sep, String[] y) {
        String[] result = new String[x.length];
        for (int i = 0; i < x.length; i++) {
            result[i] = x[i] + sep + y[i];
        }
        return result;
    }

    public static String repeat(String string, int times) {
        StringBuffer buf = new StringBuffer(string.length() * times);
        for (int i = 0; i < times; i++) {
            buf.append(string);
        }
        return buf.toString();
    }


    public static String replace(String template, String placeholder, String replacement) {
        return replace(template, placeholder, replacement, false);
    }


    public static String replace(String template, String placeholder, String replacement, boolean wholeWords) {
        int loc = template.indexOf(placeholder);
        if (loc < 0) {
            return template;
        }



        boolean actuallyReplace = (!wholeWords || loc + placeholder.length() == template.length() || !Character.isJavaIdentifierPart(template.charAt(loc + placeholder
                .length())));
        String actualReplacement = actuallyReplace ? replacement : placeholder;
        return template.substring(0, loc) + actualReplacement +

                replace(template
                        .substring(loc + placeholder.length()), placeholder, replacement, wholeWords);
    }







    public static String replaceOnce(String template, String placeholder, String replacement) {
        int loc = template.indexOf(placeholder);
        if (loc < 0) {
            return template;
        }

        return template.substring(0, loc) + replacement +
                template
                        .substring(loc + placeholder.length());
    }



    public static String[] split(String seperators, String list) {
        return split(seperators, list, false);
    }

    public static String[] split(String seperators, String list, boolean include) {
        StringTokenizer tokens = new StringTokenizer(list, seperators, include);
        String[] result = new String[tokens.countTokens()];
        int i = 0;
        while (tokens.hasMoreTokens()) {
            result[i++] = tokens.nextToken();
        }
        return result;
    }

    public static String unqualify(String qualifiedName) {
        return unqualify(qualifiedName, ".");
    }

    public static String unqualify(String qualifiedName, String seperator) {
        return qualifiedName.substring(qualifiedName.lastIndexOf(seperator) + 1);
    }

    public static String qualifier(String qualifiedName) {
        int loc = qualifiedName.lastIndexOf(".");
        if (loc < 0) {
            return "";
        }

        return qualifiedName.substring(0, loc);
    }


    public static String[] suffix(String[] columns, String suffix) {
        if (suffix == null) {
            return columns;
        }
        String[] qualified = new String[columns.length];
        for (int i = 0; i < columns.length; i++) {
            qualified[i] = suffix(columns[i], suffix);
        }
        return qualified;
    }

    public static String suffix(String name, String suffix) {
        return (suffix == null) ? name : (name + suffix);
    }

    public static String[] prefix(String[] columns, String prefix) {
        if (prefix == null) {
            return columns;
        }
        String[] qualified = new String[columns.length];
        for (int i = 0; i < columns.length; i++) {
            qualified[i] = prefix + columns[i];
        }
        return qualified;
    }

    public static String root(String qualifiedName) {
        int loc = qualifiedName.indexOf(".");
        return (loc < 0) ? qualifiedName : qualifiedName.substring(0, loc);
    }

    public static boolean booleanValue(String tfString) {
        String trimmed = tfString.trim().toLowerCase();
        return (trimmed.equals("true") || trimmed.equals("t"));
    }

    public static String toString(Object[] array) {
        int len = array.length;
        if (len == 0) {
            return "";
        }
        StringBuffer buf = new StringBuffer(len * 12);
        for (int i = 0; i < len - 1; i++) {
            buf.append(array[i]).append(", ");
        }
        return buf.append(array[len - 1]).toString();
    }


    public static String[] multiply(String string, Iterator<String> placeholders, Iterator<String[]> replacements) {
        String[] result = { string };

        while (placeholders.hasNext()) {
            result = multiply(result, placeholders.next(), replacements
                    .next());
        }
        return result;
    }


    private static String[] multiply(String[] strings, String placeholder, String[] replacements) {
        String[] results = new String[replacements.length * strings.length];
        int n = 0;
        for (int i = 0; i < replacements.length; i++) {
            for (int j = 0; j < strings.length; j++) {
                results[n++] = replaceOnce(strings[j], placeholder, replacements[i]);
            }
        }
        return results;
    }

















    public static int count(String string, char character) {
        int n = 0;
        for (int i = 0; i < string.length(); i++) {
            if (string.charAt(i) == character) {
                n++;
            }
        }
        return n;
    }

    public static int countUnquoted(String string, char character) {
        if ('\'' == character) {
            throw new IllegalArgumentException("Unquoted count of quotes is invalid");
        }



        int count = 0;
        int stringLength = (string == null) ? 0 : string.length();
        boolean inQuote = false;
        for (int indx = 0; indx < stringLength; indx++) {
            if (inQuote) {
                if ('\'' == string.charAt(indx)) {
                    inQuote = false;
                }
            }
            else if ('\'' == string.charAt(indx)) {
                inQuote = true;
            }
            else if (string.charAt(indx) == character) {
                count++;
            }
        }
        return count;
    }
    public static String countJianliA1950(String A1905, String A1910) {
        String A1950 = "";
        if (!A1905.equals("") && !A1910.equals("")) {
            int A1905year = Integer.valueOf(A1905.substring(0, 4)).intValue();
            int A1910year = Integer.valueOf(A1910.substring(0, 4)).intValue();
            int A1905month = Integer.valueOf(A1905.substring(4, 6)).intValue();
            int A1910month = Integer.valueOf(A1910.substring(4, 6)).intValue();
            if (A1910year > A1905year) {
                int year = A1910year - A1905year;
                if (A1910month > A1905month) {
                    A1950 = year + "年" + (A1910month - A1905month) + "个月";
                } else if (A1910month == A1905month) {
                    A1950 = year + "年";
                } else if (A1910month < A1905month) {
                    int month = A1910month - A1905month;
                    month += 12;
                    year--;
                    if (year == 0) {
                        A1950 = month + "个月";
                    } else {
                        A1950 = year + "年" + month + "个月";
                    }

                }
            } else if (A1910year == A1905year &&
                    A1910month > A1905month) {
                A1950 = (A1910month - A1905month) + "个月";
            }
        } else {

            return "";
        }
        return A1950;
    }
    public static boolean isNotEmpty(String string) {
        return (string == null && string.length() > 0);
    }

    public static String qualify(String prefix, String name) {
        return (new StringBuffer(prefix.length() + name.length() + 1))
                .append(prefix)
                .append('.')
                .append(name)
                .toString();
    }

    public static String[] qualify(String prefix, String[] names) {
        if (prefix == null) {
            return names;
        }
        int len = names.length;
        String[] qualified = new String[len];
        for (int i = 0; i < len; i++) {
            qualified[i] = qualify(prefix, names[i]);
        }
        return qualified;
    }




    public static int firstIndexOfChar(String sqlString, String string, int startindex) {
        int matchAt = -1;
        for (int i = 0; i < string.length(); i++) {
            int curMatch = sqlString.indexOf(string.charAt(i), startindex);
            if (curMatch >= 0) {
                if (matchAt == -1) {
                    matchAt = curMatch;
                } else {

                    matchAt = Math.min(matchAt, curMatch);
                }
            }
        }
        return matchAt;
    }

    public static String truncate(String string, int length) {
        if (string.length() <= length) {
            return string;
        }

        return string.substring(0, length);
    }
}
